home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / PC Card Manager / CIncludes / PCCard.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-25  |  20.5 KB  |  467 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        PCCard.h
  3.  
  4.      Contains:    PC Card Family Programming interface
  5.  
  6.      Version:    System 7.5 and System 8
  7.  
  8.      DRI:        Dave Falkenburg
  9.  
  10.      Copyright:    © 1984-1996 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Warning:    *** APPLE INTERNAL USE ONLY ***
  14.                  This file may contain unreleased API's
  15.  
  16.      BuildInfo:    Built by:            System Seven Interfaces Daemon
  17.                  With Interfacer:    2.0d11   (PowerPC native)
  18.                  From:                PCCard.i
  19.                      Revision:        22
  20.                      Dated:            9/18/96
  21.                      Last change by:    DRF
  22.                      Last comment:    added EJECTION_COMPLETE message code
  23.  
  24.      Bugs:        Report bugs to Radar component “System Interfaces”, “Latest”
  25.                  List the version information (from above) in the Problem Description.
  26.  
  27. */
  28. #ifndef __PCCARD__
  29. #define __PCCARD__
  30.  
  31. #ifndef __TYPES__
  32. #include <Types.h>
  33. #endif
  34. #ifndef __NAMEREGISTRY__
  35. #include <NameRegistry.h>
  36. #endif
  37.  
  38. #ifdef __cplusplus
  39. extern "C" {
  40. #endif
  41.  
  42. #if PRAGMA_IMPORT_SUPPORTED
  43. #pragma import on
  44. #endif
  45.  
  46. #if PRAGMA_ALIGN_SUPPORTED
  47. #pragma options align=power
  48. /* the following contents can only be used by compilers that support PowerPC struct alignment */
  49.  
  50. /*    Copyright:    © 1996 SystemSoft Corporation, all rights reserved. */
  51.  
  52. enum {
  53.     kServiceCategoryPCCard        = 'pccd'
  54. };
  55.  
  56. typedef UInt32 PCCardEvent;
  57. typedef UInt32 PCCardEventMask;
  58. typedef UInt32 PCCardClientID;
  59. typedef UInt32 PCCardTimerID;
  60. typedef UInt32 PCCardSocket;
  61. typedef UInt32 PCCardWindowID;
  62. typedef UInt32 PCCardWindowType;
  63. typedef UInt32 PCCardWindowSize;
  64. typedef UInt32 PCCardWindowOffset;
  65. typedef UInt32 PCCardWindowAlign;
  66. typedef OptionBits PCCardWindowState;
  67. typedef UInt32 PCCardAccessSpeed;
  68. typedef UInt32 PCCardWindowParam;
  69. typedef UInt32 PCCardPage;
  70. typedef UInt32 PCCardVoltage;
  71. /* Client notification bit flags */
  72.  
  73. enum {
  74.     kPCCardNullMessage            = 0x00000000,                    /* no messages pending (not sent to clients)*/
  75.     kPCCardInsertionMessage        = 0x00000001,                    /* card has been inserted into the socket*/
  76.     kPCCardRemovalMessage        = 0x00000002,                    /* card has been removed from the socket- do not touch hardware!*/
  77.     kPCCardLockMessage            = 0x00000004,                    /* card is locked into the socket with a mechanical latch*/
  78.     kPCCardUnlockMessage        = 0x00000008,                    /* card is no longer locked into the socket*/
  79.     kPCCardReadyMessage            = 0x00000010,                    /* card is ready to be accessed*/
  80.     kPCCardResetMessage            = 0x00000020,                    /* physical reset has completed*/
  81.     kPCCardInsertionRequestMessage = 0x00000040,                /* request to insert a card using insertion motor*/
  82.     kPCCardInsertionCompleteMessage = 0x00000080,                /* insertion motor has finished inserting a card*/
  83.     kPCCardEjectionRequestMessage = 0x00000100,                    /* user or other client is requesting a card ejection*/
  84.     kPCCardEjectionCompleteMessage = 0x00000200,                /* card ejection succeeded- do not touch hardware! */
  85.     kPCCardEjectionFailedMessage = 0x00000400,                    /* eject failure due to electrical/mechanical problems*/
  86.     kPCCardPMResumeMessage        = 0x00000800,                    /* power management resume (TBD)*/
  87.     kPCCardPMSuspendMessage        = 0x00001000,                    /* power management suspend (TBD)*/
  88.     kPCCardPMSuspendRequest        = 0x00002000,                    /* power management sleep request (TBD)*/
  89.     kPCCardPMSuspendRevoke        = 0x00004000,                    /* power management sleep revoke  (TBD)*/
  90.     kPCCardResetPhysicalMessage    = 0x00008000,                    /* physical reset is about to occur on this card*/
  91.     kPCCardResetRequestMessage    = 0x00010000,                    /* physical reset has been requested by a client*/
  92.     kPCCardResetCompleteMessage    = 0x00020000,                    /* ResetCard() background reset has completed*/
  93.     kPCCardBatteryDeadMessage    = 0x00040000,                    /* battery is no longer useable, data will be lost*/
  94.     kPCCardBatteryLowMessage    = 0x00080000,                    /* battery is weak and should be replaced*/
  95.     kPCCardWriteProtectMessage    = 0x00100000,                    /* card is now write protected*/
  96.     kPCCardWriteEnabledMessage    = 0x00200000,                    /* card is now write enabled*/
  97.     kPCCardClientInfoMessage    = 0x00400000,                    /* client is to return client information*/
  98.     kPCCardSSUpdatedMessage        = 0x00800000,                    /* AddSocketServices/ReplaceSocket services has changed SS support*/
  99.     kPCCardFunctionInterruptMessage = 0x01000000,                /* card function interrupt*/
  100.     kPCCardAccessErrorMessage    = 0x02000000,                    /* client bus errored on access to socket*/
  101.     kPCCardUnconfiguredMessage    = 0x04000000,                    /* a CARD_READY was delivered to all clients and no client */
  102.                                                                 /*    requested a configuration for the socket*/
  103.     kPCCardStatusChangedMessage    = 0x08000000,                    /* status change for cards in I/O mode*/
  104.     kPCCardTimerExpiredMessage    = 0x10000000,                    /* message sent when requested time has expired */
  105.     kPCCardRequestAttentionMessage = 0x20000000,
  106.     kPCCardEraseCompleteMessage    = 0x40000000,
  107.     kPCCardRegistrationCompleteMessage = 0x80000000
  108. };
  109.  
  110. typedef OptionBits PCCardWindowAttributes;
  111. /*    window state (values of PCCardWindowAttributes) */
  112. enum {
  113.     kWSCommon                    = 0x00000001,            /* common memory window */
  114.     kWSAttribute                = 0x00000002,            /* attribute memory window */
  115.     kWSIO                        = 0x00000004,            /* I/O window */
  116.     kWSCardBus                    = 0x00000008,            /* CardBus bridge window */
  117.     kWSTypeMask                    = 0x0000000F,            /* window type mask */
  118.     kWS8bit                        = 0x00000010,            /* 8-bit data width window */
  119.     kWS16bit                    = 0x00000020,            /* 16-bit data width window */
  120.     kWS32bit                    = 0x00000040,            /* 32-bit data width window */
  121.     kWSAutoSize                    = 0x00000080,            /* auto-size data width window */
  122.     kWSWidthMask                = 0x000000F0,            /* window data width mask */
  123.     kWSEnabled                    = 0x00000100,            /* window enabled */ 
  124.     kWSProtected                = 0x00000200,            /* window write protected */
  125.     kWSPrefetchable                = 0x00000400,            /* bridge window prefetchable */
  126.     kWSPageShared                = 0x00000800,            /* page register is shared */
  127.  
  128.     kWSWindowSizeOffset            = 0x40000000,
  129.     kWSChangeAccessSpeed        = 0x80000000            /* Used by CSModifyWindow only */
  130. };
  131.  
  132. typedef UInt32 PCCardInterfaceType;
  133. /* InterfaceType bit-mask (values of PCCardInterfaceType) */
  134.  
  135. enum {
  136.     kIFTypeMask                    = 0x03,                            /* IO & memory type mask*/
  137.     kIFCardBus                    = 0x00,                            /* if bits 0 & 1 are zero then cardbus interface*/
  138.     kIFMemory                    = 0x01,                            /* if bit 0 set memory IF*/
  139.     kIFIO                        = 0x02,                            /* if bit 1 set IO IF*/
  140.     kIFReserved                    = 0x03,                            /* bits 0 and 1 set is reserved */
  141.     kIFDMA                        = 0x08,                            /* if bit 3 set DMA supported*/
  142.     kIFVSKey                    = 0x10,                            /* if bit 4 set supports low Voltage key*/
  143.     kIF33VCC                    = 0x20,                            /* if bit 5 set socket suports 3.3v*/
  144.     kIFXXVCC                    = 0x40,                            /* if bit 6 set socket supports X.X voltage*/
  145.     kIFYYVCC                    = 0x80                            /* if bit 7 set socket supports Y.Y voltage*/
  146. };
  147.  
  148. typedef UInt32 PCCardCustomInterfaceID;
  149. /* Custom Interface Identifiers (values of PCCardCustomInterfaceID) */
  150.  
  151. enum {
  152.     kIFCustom_None                = 0x00,                            /* no custom interface ID */
  153.     kIFCustom_ZOOM                = 0x41                            /* ZOOM Video Mode custom interface identifier */
  154. };
  155.  
  156. typedef OptionBits PCCardConfigOptions;
  157. /* Bit mask values for PCCardConfigOptions in the configuration calls */
  158.  
  159. enum {
  160.     kEnableIRQSteering            = 0x0002,
  161.     kIRQChangeValid                = 0x0004,
  162.     kVppChangeValid                = 0x0010,
  163.     kEnableDMAChannel            = 0x0040,
  164.     kDMAChangeValid                = 0x0080,
  165.     kVSOverride                    = 0x0200                        /* Bits 10..31 reserved */
  166. };
  167.  
  168. typedef UInt32 PCCardConfigPresentMask;
  169. typedef UInt32 PCCardConfigRegisterIndex;
  170. typedef UInt32 PCCardConfigRegisterOffset;
  171. struct PCCardFunctionConfigReg {
  172.     Byte                             configOptionReg;
  173.     Byte                             configStatusReg;
  174.     Byte                             pinReplaceReg;
  175.     Byte                             socketCopyReg;
  176.     Byte                             extendedStatusReg;
  177.     Byte                             ioBase0;
  178.     Byte                             ioBase1;
  179.     Byte                             ioBase2;
  180.     Byte                             ioBase3;
  181.     Byte                             ioLimit;
  182. };
  183. typedef struct PCCardFunctionConfigReg PCCardFunctionConfigReg;
  184.  
  185. typedef OptionBits PCCardSocketStatus;
  186. /*    general socket status bits (values of PCCardSocketStatus) */
  187.  
  188. enum {
  189.     kSTBatteryDead                = 0x0001,                        /* battery dead*/
  190.     kSTBatteryLow                = 0x0002,                        /* battery low*/
  191.     kSTBatteryGood                = 0x0004,                        /* battery good*/
  192.     kSTPower                    = 0x0008,                        /* power is applied*/
  193.     kST16bit                    = 0x0010,                        /* 16-bit PC Card present*/
  194.     kSTCardBus                    = 0x0020,                        /* CardBus PC Card present*/
  195.     kSTMemoryCard                = 0x0040,                        /* memory card present*/
  196.     kSTIOCard                    = 0x0080,                        /* I/O card present*/
  197.     kSTNotACard                    = 0x0100,                        /* unrecognizable PC Card detected*/
  198.     kSTReady                    = 0x0200,                        /* ready*/
  199.     kSTWriteProtect                = 0x0400,                        /* card is write-protected*/
  200.     kSTDataLost                    = 0x0800,                        /* data may have been lost due to card removal*/
  201.     kSTRingIndicate                = 0x1000,                        /* ring indicator is active*/
  202.     kSTReserved                    = 0xE000
  203. };
  204.  
  205. /* Bit mask for PCCardPowerOptions in the power management calls */
  206. typedef OptionBits PCCardPowerOptions;
  207.  
  208. enum {
  209.     kPCCardPowerOn                = 0x00000001,
  210.     kPCCardPowerOff                = 0x00000002,
  211.     kPCCardLowPower                = 0x00000004
  212. };
  213.  
  214. typedef OptionBits PCCardAdapterCapabilities;
  215. typedef UInt32 PCCardAdapterPowerState;
  216. typedef OptionBits PCCardSCEvents;
  217. typedef UInt32 PCCardWindow;
  218. typedef UInt32 PCCardIRQ;
  219. typedef UInt32 PCCardDMA;
  220. /* Types and structures for accessing the PCCard Assigned-Address property.*/
  221. #define kPCCardAssignedAddressProperty "assigned-addresses"
  222.  
  223. enum {
  224.     kPCCardNonRelocatableSpace    = 0x80,
  225.     kPCCardPrefetchableSpace    = 0x40,
  226.     kPCCard16BitSpace            = 0x20,
  227.     kPCCardAddressTypeCodeMask    = 0x07,
  228.     kPCCardConfigSpace            = 0,
  229.     kPCCardIOSpace                = 1,
  230.     kPCCardMemorySpace            = 2,
  231.     kPCCardAttributeMemorySpace    = 4
  232. };
  233.  
  234. typedef UInt8 PCCardAddressSpaceFlags;
  235.  
  236. enum {
  237.     kPCCardSocketNumberMask        = 0xF8,
  238.     kPCCardFunctionNumberMask    = 0x07
  239. };
  240.  
  241. typedef UInt8 PCCardSocketFunction;
  242. typedef UInt8 PCCardBusNumber;
  243. typedef UInt8 PCCardRegisterNumber;
  244. struct PCCardAssignedAddress {
  245.     PCCardAddressSpaceFlags         addressSpaceFlags;
  246.     UInt8                             reserved;
  247.     PCCardSocketFunction             socketFunctionNumber;
  248.     PCCardRegisterNumber             registerNumber;
  249.     UInt32                             address;
  250.     UInt32                             size;
  251. };
  252. typedef struct PCCardAssignedAddress PCCardAssignedAddress;
  253.  
  254. typedef PCCardAssignedAddress *PCCardAssignedAddressPtr;
  255. #define GetPCCardIsNonRelocatable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardNonRelocatableSpace)
  256. #define GetPCCardIsPrefetchable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardPrefetchableSpace)
  257. #define GetPCCardIs16BitSpace( AssignedAddressPtr )            ((AssignedAddressPtr)->addressSpaceFlags & kPCCard16BitSpace)
  258. #define GetPCCardAddressSpaceType( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardAddressTypeCodeMask)
  259. #define GetPCCardSocketNumber( AssignedAddressPtr )            (((AssignedAddressPtr)->socketFunctionNumber >> 3) & kPCCardSocketNumberMask)
  260. #define GetPCCardFunctionNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->socketFunctionNumber & kPCCardFunctionNumberMask)
  261. #define GetPCCardRegisterNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->registerNumber)
  262. /*
  263. ----------------------------------------------------------------------
  264.     Client Support
  265. ----------------------------------------------------------------------
  266. */
  267. /* Prototype for client callback */
  268. typedef OSStatus (*PCCardEventHandler)(PCCardEvent theEvent, PCCardSocket vSocket, UInt32 device, UInt32 info, UInt32 MTDRequest, UInt32 *Buffer, UInt32 misc, UInt32 status, void *clientParam);
  269. extern OSStatus PCCardRegisterClient(const RegEntryRef *deviceRef, PCCardEventMask eventMask, PCCardEventHandler clientCallBack, void *clientParam, PCCardClientID *newClientID);
  270.  
  271. extern OSStatus PCCardDeRegisterClient(PCCardClientID theClientID);
  272.  
  273. extern OSStatus PCCardRegisterTimer(PCCardClientID registeredClientID, PCCardTimerID *lpNewTimerID, long delay);
  274.  
  275. extern void PCCardDeRegisterTimer(PCCardTimerID timerID);
  276.  
  277. extern OSStatus PCCardSetEventMask(PCCardClientID theClientID, PCCardEventMask newEventMask);
  278.  
  279. extern OSStatus PCCardGetEventMask(PCCardClientID theClientID, PCCardEventMask *newEventMask);
  280.  
  281. extern OSStatus PCCardGetCardServicesInfo(ItemCount *socketCount, UInt32 *complianceLevel, UInt32 *version);
  282.  
  283. extern OSStatus PCCardGetSocketRef(PCCardSocket vSocket, RegEntryRef *socketRef);
  284.  
  285. extern OSStatus PCCardGetCardRef(PCCardSocket vSocket, RegEntryRef *cardRef);
  286.  
  287. extern OSStatus PCCardGetSocketAndDeviceFromDeviceRef(const RegEntryRef *deviceRef, PCCardSocket *vSocket, UInt32 *device);
  288.  
  289. extern OSStatus PCCardGetCardRefFromDeviceRef(const RegEntryRef *deviceRef, RegEntryRef *cardRef);
  290.  
  291. /*
  292. ----------------------------------------------------------------------
  293.     Resource Management
  294. ----------------------------------------------------------------------
  295. */
  296. extern OSStatus PCCardRequestWindow(const RegEntryRef *deviceRef, PCCardWindowAttributes windowAttributes, LogicalAddress *windowBase, ByteCount *windowSize, PCCardAccessSpeed *windowSpeed, PCCardWindowOffset *windowOffset, PCCardWindowID *windowID);
  297.  
  298. extern OSStatus PCCardModifyWindow(PCCardWindowID windowID, PCCardWindowAttributes windowAttributes, PCCardAccessSpeed windowSpeed, PCCardWindowOffset windowOffset);
  299.  
  300. extern OSStatus PCCardReleaseWindow(PCCardWindowID windowID);
  301.  
  302. extern OSStatus PCCardGetStatus(const RegEntryRef *deviceRef, UInt32 *currentState, UInt32 *changedState, PCCardVoltage *Vcc, PCCardVoltage *Vpp);
  303.  
  304. extern OSStatus PCCardRequestConfiguration(const RegEntryRef *deviceRef, PCCardConfigOptions configOptions, PCCardInterfaceType ifType, PCCardCustomInterfaceID ifCustomType, PCCardVoltage vcc, PCCardVoltage vpp, LogicalAddress configRegistersBase, PCCardConfigPresentMask configRegistersPresent, PCCardFunctionConfigReg *configRegisterValues);
  305.  
  306. extern OSStatus PCCardReleaseConfiguration(const RegEntryRef *deviceRef);
  307.  
  308. extern OSStatus PCCardModifyConfiguration(const RegEntryRef *deviceRef, PCCardConfigOptions configOptions, PCCardVoltage vpp);
  309.  
  310. extern OSStatus PCCardSetRingIndicate(const RegEntryRef *deviceRef, Boolean setRingIndicate);
  311.  
  312. extern OSStatus PCCardReadConfigurationRegister(const RegEntryRef *deviceRef, PCCardConfigRegisterIndex whichRegister, PCCardConfigRegisterOffset offset, UInt8 *value);
  313.  
  314. extern OSStatus PCCardWriteConfigurationRegister(const RegEntryRef *deviceRef, PCCardConfigRegisterIndex whichRegister, PCCardConfigRegisterOffset offset, UInt8 value);
  315.  
  316. extern OSStatus PCCardResetFunction(const RegEntryRef *deviceRef);
  317.  
  318. /*
  319. ----------------------------------------------------------------------
  320.     Client Utilities
  321. ----------------------------------------------------------------------
  322. */
  323. typedef UInt8 PCCardTupleKind;
  324. typedef struct OpaquePCCardTupleIterator* PCCardTupleIterator;
  325. extern PCCardTupleIterator PCCardNewTupleIterator(void );
  326.  
  327. extern OSStatus PCCardDisposeTupleIterator(PCCardTupleIterator tupleIterator);
  328.  
  329. extern OSStatus PCCardGetFirstTuple(const RegEntryRef *deviceID, PCCardTupleKind desiredTuple, PCCardTupleIterator tupleIterator, void *dataBuffer, UInt32 *dataBufferSize, PCCardTupleKind *foundTuple, UInt32 *foundTupleDataSize);
  330.  
  331. extern OSStatus PCCardGetNextTuple(const RegEntryRef *deviceRef, PCCardTupleKind desiredTuple, PCCardTupleIterator tupleIterator, void *dataBuffer, UInt32 *dataBufferSize, PCCardTupleKind *foundTuple, UInt32 *foundTupleDataSize);
  332.  
  333. /*
  334. ----------------------------------------------------------------------
  335.     Miscellaneous
  336. ----------------------------------------------------------------------
  337. */
  338. extern OSStatus PCCardEject(const RegEntryRef *cardRef);
  339.  
  340. typedef UInt32 PCCardDevType;
  341. typedef UInt32 PCCardSubType;
  342. /* values for PCCardType and PCCardSubType*/
  343.  
  344. enum {
  345.     kPCCardUnknownType            = 0,
  346.     kPCCardMultiFunctionType    = 1,
  347.     kPCCardMemoryType            = 2,
  348.     kPCCardNullSubType            = 0,    // Memory sub types
  349.     kPCCardRomSubType            = 1,
  350.     kPCCardOTPromSubType        = 2,
  351.     kPCCardEpromSubType            = 3,
  352.     kPCCardEEpromSubType        = 4,
  353.     kPCCardFlashSubType            = 5,
  354.     kPCCardSramSubType            = 6,
  355.     kPCCardDramSubType            = 7,
  356.     kPCCardSerialPortType        = 3,    
  357.     kPCCardSerialOnlySubType    = 0,    // serial sub types
  358.     kPCCardDataModemSubType        = 1,
  359.     kPCCardFaxModemSubType        = 2,
  360.     kPCCardFaxAndDataModemMask    = (kPCCardDataModemSubType | kPCCardFaxModemSubType),
  361.     kPCCardVoiceEncodingSubType    = 4,
  362.     kPCCardParallelPortType        = 4,
  363.     kPCCardFixedDiskType        = 5,
  364.     kPCCardUnknownFixedDiskType    = 0,
  365.     kPCCardATAInterfaceDiskSubType = 1,
  366.     kPCCardRotatingDeviceSubType = (0 << 7),
  367.     kPCCardSiliconDevice        = (1 << 7),
  368.     kPCCardVideoAdaptorType        = 6,
  369.     kPCCardNetworkAdaptorType    = 7,
  370.     kPCCardArcNetSubType         = 1,    // network sub types
  371.     kPCCardEthernetSubType         = 2,
  372.     kPCCardTokenRingSubType     = 3,
  373.     kPCCardLocalTalkSubType     = 4,
  374.     kPCCardFDDI_CDDISubType     = 5,
  375.     kPCCardATMSubType             = 6,
  376.     kPCCardWirelessSubType         = 7,
  377.     kPCCardAIMSType                = 8,
  378.     kPCCardSCSIType                = 9
  379. };
  380.  
  381. extern OSStatus PCCardGetCardInfo(const RegEntryRef *cardRef, PCCardDevType *cardType, PCCardSubType *cardSubType, StringPtr cardName, StringPtr vendorName);
  382.  
  383.  
  384. enum {
  385.     kPCCard16HardwareType        = 'pc16',
  386.     kCardBusHardwareType        = 'cdbs'
  387. };
  388.  
  389. typedef UInt32 PCCardHardwareType;
  390. /* error codes */
  391.  
  392. enum {
  393.     kBadAdapterErr                = -9050,                        /* invalid adapter number*/
  394.     kBadAttributeErr            = -9051,                        /* specified attributes field value is invalid*/
  395.     kBadBaseErr                    = -9052,                        /* specified base system memory address is invalid*/
  396.     kBadEDCErr                    = -9053,                        /* specified EDC generator specified is invalid*/
  397.     kBadIRQErr                    = -9054,                        /* specified IRQ level is invalid*/
  398.     kBadOffsetErr                = -9055,                        /* specified PC card memory array offset is invalid*/
  399.     kBadPageErr                    = -9056,                        /* specified page is invalid*/
  400.     kBadSizeErr                    = -9057,                        /* specified size is invalid*/
  401.     kBadSocketErr                = -9058,                        /* specified logical or physical socket number is invalid*/
  402.     kBadTypeErr                    = -9059,                        /* specified window or interface type is invalid*/
  403.     kBadVccErr                    = -9060,                        /* specified Vcc power level index is invalid*/
  404.     kBadVppErr                    = -9061,                        /* specified Vpp1 or Vpp2 power level index is invalid*/
  405.     kBadWindowErr                = -9062,                        /* specified window is invalid*/
  406.     kBadArgLengthErr            = -9063,                        /* ArgLength argument is invalid*/
  407.     kBadArgsErr                    = -9064,                        /* values in argument packet are invalid*/
  408.     kBadHandleErr                = -9065,                        /* clientHandle is invalid*/
  409.     kBadCISErr                    = -9066,                        /* CIS on card is invalid*/
  410.     kBadSpeedErr                = -9067,                        /* specified speed is unavailable*/
  411.     kReadFailureErr                = -9068,                        /* unable to complete read request*/
  412.     kWriteFailureErr            = -9069,                        /* unable to complete write request*/
  413.     kGeneralFailureErr            = -9070,                        /* an undefined error has occurred*/
  414.     kNoCardErr                    = -9071,                        /* no PC card in the socket*/
  415.     kUnsupportedFunctionErr        = -9072,                        /* function is not supported by this implementation*/
  416.     kUnsupportedModeErr            = -9073,                        /* mode is not supported*/
  417.     kBusyErr                    = -9074,                        /* unable to process request at this time - try later*/
  418.     kWriteProtectedErr            = -9075,                        /* media is write-protected*/
  419.     kConfigurationLockedErr        = -9076,                        /* a configuration has already been locked*/
  420.     kInUseErr                    = -9077,                        /* requested resource is being used by a client*/
  421.     kNoMoreItemsErr                = -9078,                        /* there are no more of the requested item*/
  422.     kOutOfResourceErr            = -9079,                        /* Card Services has exhausted the resource*/
  423.     kNoCardSevicesSocketsErr    = -9080,
  424.     kInvalidRegEntryErr            = -9081,
  425.     kBadLinkErr                    = -9082,
  426.     kBadDeviceErr                = -9083,
  427.     k16BitCardErr                = -9084,
  428.     kCardBusCardErr                = -9085,
  429.     kPassCallToChainErr            = -9086,
  430.     kCantConfigureCardErr        = -9087,
  431.     kPostCardEventErr            = -9088,                        /* _PCCSLPostCardEvent failed and dropped an event */
  432.     kInvalidDeviceNumber        = -9089,
  433.     kUnsupportedVsErr            = -9090,                        /* Unsupported Voltage Sense */
  434.     kInvalidCSClientErr            = -9091,                        /* Card Services ClientID is not registered */
  435.     kBadTupleDataErr            = -9092,                        /* Data in tuple is invalid */
  436.     kBadCustomIFIDErr            = -9093,                        /* Custom interface ID is invalid */
  437.     kNoIOWindowRequestedErr        = -9094,                        /* Request I/O window before calling configuration */
  438.     kNoMoreTimerClientsErr        = -9095,                        /* All timer callbacks are in use */
  439.     kNoMoreInterruptSlotsErr    = -9096,                        /* All internal Interrupt slots are in use */
  440.     kNoClientTableErr            = -9097,                        /* The client table has not be initialized yet */
  441.     kUnsupportedCardErr            = -9098,                        /* Card not supported by generic enabler*/
  442.     kNoCardEnablersFoundErr        = -9099,                        /* No Enablers were found*/
  443.     kNoEnablerForCardErr        = -9100,                        /* No Enablers were found that can support the card*/
  444.     kNoCompatibleNameErr        = -9101,                        /* There is no compatible driver name for this device*/
  445.     kClientRequestDenied        = -9102,                        /* CS Clients should return this code inorder to */
  446.                                                                 /*   deny a request-type CS Event                */
  447.     kNotReadyErr                = -9103,                        /* PC Card failed to go ready */
  448.     kTooManyIOWindowsErr        = -9104,                        /* device requested more than one I/O window */
  449.     kAlreadySavedStateErr        = -9105,                        /* The state has been saved on previous call */
  450.     kAttemptDupCardEntryErr        = -9106                            /* The Enabler was asked to create a duplicate card entry */
  451. };
  452.  
  453.  
  454. #pragma options align=reset
  455. #endif /* PRAGMA_ALIGN_SUPPORTED */
  456.  
  457. #if PRAGMA_IMPORT_SUPPORTED
  458. #pragma import off
  459. #endif
  460.  
  461. #ifdef __cplusplus
  462. }
  463. #endif
  464.  
  465. #endif /* __PCCARD__ */
  466.  
  467.